/**
 * Redis配置文件
 * 包含Redis连接配置、缓存前缀、TTL设置和工具函数
 */

import { createClient, RedisClientType } from 'redis';
import appConfig from './index';

// 缓存前缀定义
export const CACHE_PREFIXES = {
  // 用户详情
  USER: 'user:',
  // 用户详情
  USER_PROFILE: 'user_profile:',
  // 用户权限
  USER_PERMISSIONS: 'user_permissions:',
  // 用户列表
  ARTIST: 'artist:',
  // 热门艺人
  ARTIST_LIST: 'artist_list:',
  // 流派统计
  ARTIST_GENRE_STATS: 'artist_genre_stats:',
  // 艺人信息
  ARTIST_INFO: 'artist_info:',
  // 艺人详情
  ARTIST_DETAIL: 'artist_detail:',
  // 演出列表
  PERFORMANCE_LIST: 'performance_list:',
  // 演出详情
  PERFORMANCE_DETAIL: 'performance_detail:',
  // 徽章列表
  BADGE_LIST: 'badge_list:',
  BADGE_DETAIL: 'badge_detail:',
  FUN_FACT_LIST: 'fun_fact_list:',
  FUN_FACT_DETAIL: 'fun_fact_detail:',
  // 通知列表
  NOTIFICATION_LIST: 'notification_list:',
  // 通知详情
  NOTIFICATION_DETAIL: 'notification_detail:',
  // 系统配置
  SYSTEM_CONFIG: 'config:',
  // 导航列表
  NAVIGATION: 'navigation:',
  // 投票列表
  VOTE: 'vote:',
  // 场地列表
  VENUE: 'venue:',
  // 人工智能助手
  AI_ASSISTANT: 'ai_assistant:'
} as const;

// 缓存TTL设置（秒）
export const CACHE_TTL = {
  /* 用户 */
  USER: 3600,
  /* 用户详情 */
  USER_PROFILE: 3600,
  /* 用户权限 */
  USER_PERMISSIONS: 1800,
  /* 用户列表 */
  USER_LIST: 3600,
  /* 艺人 */
  ARTIST_LIST: 3600,
  /* 艺人流派统计 */
  ARTIST_GENRE_STATS: 3600,
  /* 艺人信息 */
  ARTIST_INFO: 3600,
  /* 艺人详情 */
  ARTIST_DETAIL: 3600,
  /* 演出 */
  PERFORMANCE_LIST: 900,
  /* 演出详情 */
  PERFORMANCE_DETAIL: 1800,
  /* 徽章 */
  BADGE_LIST: 7200,
  /* 趣事 */
  FUN_FACT_LIST: 7200,
  /* 系统配置 */
  SYSTEM_CONFIG: 86400,
  /* 导航 */
  NAVIGATION_MAP: 1800,
  /* 导航路线 */
  NAVIGATION_ROUTE: 900,
  /* 通知 */
  NOTIFICATION_LIST: 300,
  /* 通知数量 */
  NOTIFICATION_COUNT: 300,
  /* 投票 */
  VOTE_RESULT: 600,
  /* 投票数量 */
  VOTE_COUNT: 300,
  /* 场地 */
  VENUE_LIST: 3600,
  /* 人工智能助手 */
  AI_ASSISTANT_CHAT: 1800,
  /* 缓存时间 */
  SHORT: 300,
  /* 缓存时间 */
  MEDIUM: 1800,
  /* 缓存时间 */
  LONG: 3600,
  /* 缓存时间 */
  VERY_LONG: 86400
} as const;

// Redis客户端实例
let redisClient: RedisClientType | null = null;

/**
 * 获取Redis客户端实例
 * @returns Redis客户端实例
 */
export async function getRedisClient(): Promise<RedisClientType> {
  if (!redisClient) {
    const dbconfig = {
      host: appConfig.cache.redis.host,
      port: appConfig.cache.redis.port,
      password: appConfig.cache.redis.password,
      database: appConfig.cache.redis.database
    };
    
    redisClient = createClient({
      url: `redis://${dbconfig.host}:${dbconfig.port}`,
      ...(dbconfig.password && { password: dbconfig.password }),
      database: dbconfig.database,
      disableOfflineQueue: true,
      socket: {
        connectTimeout: 10000,
        keepAlive: 10000,
        reconnectStrategy: (retries: number) => {
          if (retries > 10) {
            console.error('Redis连接重试次数过多，停止重连');
            return false;
          }
          return Math.min(retries * 100, 3000);
        }
      }
    });
    
    redisClient.on('error', (err) => {
      console.error('Redis连接错误:', err);
    });
    
    redisClient.on('connect', () => {
      console.log('Redis连接成功');
    });
    
    redisClient.on('ready', () => {
      console.log('Redis客户端就绪');
    });
    
    redisClient.on('end', () => {
      console.log('Redis连接已关闭');
    });
    
    await redisClient.connect();
  }
  
  return redisClient;
}

/**
 * 关闭Redis连接
 */
export async function closeRedisConnection(): Promise<void> {
  if (redisClient) {
      await redisClient.quit();
      redisClient = null;
    console.log('Redis连接已关闭');
  }
}

/**
 * 生成缓存键
 */
export function generateCacheKey(prefix: string, key: string | number): string {
  return `${prefix}${key}`;
}

/**
 * 生成列表缓存键
 */
export function generateListCacheKey(prefix: string, params: Record<string, any>): string {
  const sortedParams = Object.keys(params)
    .sort()
    .map(key => `${key}=${params[key]}`)
    .join('&');
  return `${prefix}list:${sortedParams}`;
}

/**
 * 根据模式删除缓存
 */
export async function deleteCacheByPattern(pattern: string): Promise<void> {
  const client = await getRedisClient();
  const keys = await client.keys(pattern);
  if (keys.length > 0) {
    await client.del(keys);
    console.log(`删除缓存键: ${keys.length} 个`);
  }
}

/**
 * 根据前缀清理缓存
 */
export async function clearCacheByPrefix(prefix: string): Promise<void> {
  await deleteCacheByPattern(`${prefix}*`);
}

/**
 * 获取缓存统计信息
 */
export async function getCacheStats(): Promise<{
  totalKeys: number;
  memoryUsage: string;
  connectedClients: number;
  uptime: number;
}> {
  const client = await getRedisClient();
  
  const [info, dbsize] = await Promise.all([
    client.info('memory'),
    client.dbSize()
  ]);
  
  const memoryMatch = info.match(/used_memory_human:(\S+)/);
  const memoryUsage = memoryMatch ? memoryMatch[1] : '0B';
  
  return {
    totalKeys: dbsize,
    memoryUsage,
    connectedClients: 1, // 简化统计
    uptime: Date.now()
  };
}

/**
 * 检查Redis健康状态
 */
export async function checkRedisHealth(): Promise<boolean> {
  try {
    const client = await getRedisClient();
    await client.ping();
    return true;
  } catch (error) {
    console.error('Redis健康检查失败:', error);
    return false;
  }
}

/**
 * 获取Redis配置
 */
export function getRedisConfig() {
  return {
    host: appConfig.cache.redis.host,
    port: appConfig.cache.redis.port,
    database: appConfig.cache.redis.database,
    enabled: appConfig.cache.redis.enabled
  };
}

// 导出类型
export type CachePrefix = typeof CACHE_PREFIXES[keyof typeof CACHE_PREFIXES];
export type CacheTTL = typeof CACHE_TTL[keyof typeof CACHE_TTL]; 